    {
        // Move fluid mesh
        const vectorField& n = 
            mesh.boundaryMesh()[fluidPatchID].pointNormals();

        primitivePatchInterpolation patchInterpolator
        (
            mesh.boundaryMesh()[fluidPatchID]
        );

        scalarField pointDeltaCoeffs =
            patchInterpolator.faceToPointInterpolate
            (
                mesh.boundary()[fluidPatchID].deltaCoeffs()
            );

        scalar delta = 
            gMax
            (
                mag
                (
                    n
                  & (
                        accumulatedFluidInterfaceDisplacement
                      + fluidPatchPointsDispl
                      - fluidPatchPointsDisplOld
                    )
                )
               *pointDeltaCoeffs
            );

        Info << "Maximal accumulated displacement of interface points: " 
            << delta << endl;

        if(delta < interfaceDeformationLimit)
        {
            // Move only interface points
            //pointField newPoints = mesh.allPoints();
            pointField newPoints = mesh.points();

            const labelList& meshPoints = 
                mesh.boundaryMesh()[fluidPatchID].meshPoints();

            forAll (fluidPatchPointsDispl, pointI)
            {
                newPoints[meshPoints[pointI]] += 
                    fluidPatchPointsDispl[pointI]
                  - fluidPatchPointsDisplOld[pointI];
            }

            twoDPointCorrector twoDCorrector(mesh);

            twoDCorrector.correctPoints(newPoints);

            mesh.movePoints(newPoints);

            // Accumulate interface points displacement
            accumulatedFluidInterfaceDisplacement += 
                fluidPatchPointsDispl
              - fluidPatchPointsDisplOld;
        }
        else
        {
            // Move whole fluid mesh
//             pointField newPoints = mesh.allPoints();
            pointField newPoints = mesh.points();

            const labelList& meshPoints = 
                mesh.boundaryMesh()[fluidPatchID].meshPoints();

            forAll (accumulatedFluidInterfaceDisplacement, pointI)
            {
                newPoints[meshPoints[pointI]] -= 
                    accumulatedFluidInterfaceDisplacement[pointI]; 
            }

            twoDPointCorrector twoDCorrector(mesh);

            twoDCorrector.correctPoints(newPoints);

            mesh.movePoints(newPoints);

            accumulatedFluidInterfaceDisplacement += 
                fluidPatchPointsDispl
              - fluidPatchPointsDisplOld;


            if (feMotionSolver)
            {
//                 tetPointVectorField& motionU =
//                     const_cast<tetPointVectorField&>
//                     (
//                         mesh.objectRegistry::
//                         lookupObject<tetPointVectorField>
//                         (
//                             "motionU"
//                         )
//                     );
                
//                 fixedValueTetPolyPatchVectorField& motionUFluidPatch =
//                     refCast<fixedValueTetPolyPatchVectorField>
//                     (
//                         motionU.boundaryField()[fluidPatchID]
//                     );

//                 tetPolyPatchInterpolation tppi
//                 (
//                     refCast<const faceTetPolyPatch>(motionUFluidPatch.patch())
//                 );

//                 motionUFluidPatch == 
//                     tppi.pointToPointInterpolate
//                     (
//                         accumulatedFluidInterfaceDisplacement
//                        /runTime.deltaT().value()
//                     );
            }
            else if (fvMotionSolver)
            {
                pointVectorField& motionU =
                    const_cast<pointVectorField&>
                    (
                        mesh.objectRegistry::
                        lookupObject<pointVectorField>
                        (
                            "pointMotionU"
                        )
                    );
	        
                fixedValuePointPatchVectorField& motionUFluidPatch =
                    refCast<fixedValuePointPatchVectorField>
                    (
                        motionU.boundaryField()[fluidPatchID]
                    );

                motionUFluidPatch == 
                    accumulatedFluidInterfaceDisplacement
                   /runTime.deltaT().value();
            }
            else
            {
                FatalErrorIn(args.executable())
                    << "Problem with mesh motion solver selection"
                        << abort(FatalError);
            }

            mesh.update();

            accumulatedFluidInterfaceDisplacement = vector::zero;
        }
    }
